home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / game / misc / videopokeri_sr.lha / VideoPokeri_102.C < prev    next >
C/C++ Source or Header  |  1995-02-03  |  62KB  |  2,271 lines
  1.  
  2. /********************************************************************
  3.  *                                                                  *
  4.  * Program      : Project VideoPokeri                               *
  5.  *                                                                  *
  6.  * Version      : 1.02      (06.11.1991)    (03.02.1995)            *
  7.  *                                                                  *
  8.  * Description  : RAY:n videopokerin kaltainen peli.                *
  9.  *                mm. tuplaus, pihistys, äänet, levylista ym. ym.   *
  10.  *                                                                  *
  11.  *                                                                  *
  12.  * CLI-usage    : [run] VideoPokeri [s] [1|2|3]                     *
  13.  *                  parametrit:   s = silencio = ei ladata soundeja *
  14.  *                                1 = SUOMI                         *
  15.  *                                2 = ENGLISH                       *
  16.  *                                3 = SVENSKA                       *
  17.  *                                                                  *
  18.  * Distribution : (C) Janne & Aki                                   *
  19.  *                                                                  *
  20.  * Bugs         : ?                                                 *
  21.  *                                                                  *
  22.  * Author       : Janne Kantola & Aki Löytynoja                     *
  23.  *                92100  RAAHE ,  FINLAND                           *
  24.  *                                                                  *
  25.  *  E-mail       : janta@ratol.fi                                   *
  26.  *                                                                  *
  27.  ********************************************************************/
  28.  
  29.  
  30. /************** ALUSTUSTIEDOSTOT *********************/
  31.  
  32. #include <proto/all.h>
  33. #include <exec/types.h>
  34. #include <exec/memory.h>
  35. #include <devices/audio.h>
  36. #include <intuition/intuition.h>
  37. #include <libraries/dos.h>
  38. #include <libraries/dosextens.h>
  39. #include <graphics/gfx.h>
  40. #include <graphics/gfxbase.h>
  41. #include <graphics/gfxmacros.h>
  42. #include <stdlib.h>
  43. #include <string.h>
  44. #include <stdio.h>
  45.  
  46. int CXBRK(void)  {return(0);}
  47.  
  48. /********************** KONFIGURAATIO-VIVUT ************************/
  49.  
  50. /* #define NOT_ENGLISH_GIFTWARE */
  51. /* When this is defined, About-window exists and default language
  52.    is Finnish */
  53.  
  54. /**************************** VAKIOT *******************************/
  55.  
  56. #define ALKUMARKAT 50           /* PELIMARKKOJA ALUSSA 50 KPL   */
  57. #define ALKUPANOS   4           /* ALKUPANOS ON 5 MK            */
  58. #define VIIVE      25           /* DELAY-VIIVE                  */
  59. #define SOUND_MAX  11           /* Soundien lukumäärä           */
  60.  
  61. const   UBYTE VERSIO[] = "$VER: VideoPokeri 1.02 (13.04.94) JanTAki";
  62.  
  63. /******************** OMAT HEADER-TIEDOSTOT ************************/
  64.  
  65. #include "Poker.h/Screen.h"     /* Näyttömääritelyt  */
  66. #include "Poker.h/Window.h"     /* Ikkunamäärittelyt */
  67. #include "Poker.h/Graphics.h"   /* Grafiikat         */
  68. #include "Poker.h/Gadgets.h"    /* Gadgetit          */
  69. #include "Poker.h/Sheets.h"     /* Taulukot, tekstit */
  70.  
  71.  
  72. /************************* ULKOISET FUNKTIOT ****************************/
  73.  
  74. extern  VOID AvaaSoundit(VOID);
  75. extern  VOID VaraaKanavat(VOID);
  76. extern  VOID Sound(SHORT, SHORT, SHORT);
  77. extern  UBYTE *sbase[];
  78. extern  ULONG ssize[];
  79.  
  80.  
  81. /************************ FUNKTIOMÄÄRITTELYT ***************************/
  82.  
  83. VOID  OpenAll(VOID);
  84. VOID  Initialize(VOID);
  85. VOID  ColorSquare(struct RastPort *, SHORT, SHORT, SHORT, SHORT, SHORT);
  86. VOID  ShadowText(struct RastPort *, SHORT, SHORT, SHORT, SHORT, BYTE *);
  87. VOID  PlainText(struct RastPort *, SHORT, SHORT, SHORT, SHORT, BYTE *);
  88. VOID  TextText(struct RastPort *, SHORT, SHORT, SHORT, BYTE *);
  89. VOID  cleanExit (SHORT);
  90. SHORT HandleUGad(struct IntuiMessage *);
  91. VOID  HandleDGad(struct IntuiMessage *);
  92. VOID  Jako(VOID);
  93. VOID  PiirraPakka(VOID);
  94. VOID  JaaAlkuKortit(VOID);
  95. VOID  JaaLoputKortit(VOID);
  96. VOID  OtaPoisJokeri(VOID);
  97. SHORT Satunnaisluku(SHORT, SHORT);
  98. VOID  DeKoodaa(VOID);
  99. SHORT TarkistaVoitot(VOID);
  100. VOID  GadgetitKondixeen(VOID);
  101. VOID  KatsoRahaTilanne(VOID);
  102. VOID  GameOver(VOID);
  103. VOID  VahennaRahaa(VOID);
  104. VOID  PrinttaaPanos(VOID);
  105. VOID  PrinttaaPelitVoitot(VOID);
  106. VOID  TekstiPelitVoitot(UBYTE);
  107. VOID  TulostaVoittoluokat(VOID);
  108. VOID  VaritRuutuun(SHORT);
  109. VOID  Valauta(VOID);
  110. VOID  PuhdistaAlapalkki(VOID);
  111. VOID  KortinGrafiikka(SHORT);
  112. VOID  KortinGrafiikkaTalteen(SHORT);
  113. VOID  TaustaKortit(VOID);
  114. VOID  TulostaKortit(VOID);
  115. VOID  TulostaKortit2(VOID);
  116. VOID  KortitPois(VOID);
  117. VOID  KortitKasaan(VOID);
  118. VOID  KortitPakkaan(VOID);
  119. VOID  KilistysAAYY(VOID);
  120. VOID  KilistysAY(VOID);
  121. VOID  KilistysYA(VOID);
  122. VOID  KilistysYY(VOID);
  123. #if defined FEA_NOT_ENGLISH_GIFTWARE
  124. VOID  Aboutti(VOID);
  125. #endif
  126. VOID  MuutaKielta(UBYTE);
  127.  
  128.  
  129. /******** SYSTEEMIMUUTTUJAT ****************************/
  130.  
  131. struct IntuitionBase *IntuitionBase = NULL;
  132. struct Library       *DiskfontBase  = NULL;
  133. struct GfxBase       *GfxBase       = NULL;
  134. struct Screen        *screen        = NULL;
  135. struct Window        *window        = NULL;
  136. struct RastPort      *RP            = NULL;
  137. struct RastPort      cardRP;
  138. struct FileHandle    *infile        = NULL;
  139. struct IOAudio       *AIOptr1       = NULL;
  140. struct IOAudio       *AIOptr2       = NULL;
  141. struct MsgPort       *port1         = NULL;
  142. struct MsgPort       *port2         = NULL;
  143. struct TextFont      *textFont;
  144. struct TextFont      *oldTextFont;
  145. struct BitMap        bitMap;
  146. struct BitMap        cardbitMap;
  147. struct TextAttr      textAttr;
  148. ULONG  device1                      = 0;
  149. ULONG  device2                      = 0;
  150.  
  151.  
  152. /******** GLOBAALIT MUUTTUJAT ****************************/
  153.  
  154. UBYTE   stringi[255];
  155. UBYTE   BON[]  = {'\x1B', '[', '1', 'm', '\x0' };
  156. UBYTE   OFF[]  = {'\x1B', '[', '3', '1', ';', '0', 'm', '\x0' };
  157. UBYTE   COL1[] = {'\x1B', '[', '3', '2', 'm', '\x0' };
  158. UBYTE   COL2[] = {'\x1B', '[', '3', '3', 'm', '\x0' };
  159.  
  160. SHORT  jokerimukana  =   (ALKUPANOS>1)?1:0; /* ONKO JOKERI MUKANA       */
  161. LONG   voitot        =   0;                 /* VOITTORAHAA YLÄKULMASSA  */
  162. SHORT  pelit         =   ALKUMARKAT;        /* PELIRAHAA JÄLJELLÄ       */
  163. SHORT  pelitilanne   =   1;                 /* MISSÄ VAIHEESSA MENNÄÄN  */
  164. SHORT  tyhjennys     =   1;                 /* ONKO PÖYTÄ TYHJÄ         */
  165. SHORT  valittu[]     =   {0,0,0,0,0};       /* KORTTIEN VALINNAT        */
  166. SHORT  panokset[]    =   {1,2,3,4,5};       /* PANOKSEN SUURUUDET       */
  167. SHORT  nytpanos      =   ALKUPANOS;         /* 4. ALKIO --> 5 mk        */
  168. SHORT  nytvoitto     =   8;                 /* MIKÄ VOITTO (8=EI TULLU) */
  169. SHORT  voittosumma   =   0;                 /* VOITTOSUMMA              */
  170. SHORT  tuplavoitto   =   0;                 /* VOITTO TUPLAUKSEN JÄLKEEN*/
  171. APTR   mypointer     =   0;                 /* POINTTERI MUISTIIN       */
  172. UBYTE  *muistinalku;                        /* POINTTERI MUISTIIN       */
  173. UBYTE  stringi[255];                        /* VARATTU TILA STRINGEILLE */
  174. UBYTE  lista[15][30];                   /* HIGHSCORE-LISTAN MUUTTUJAT   */
  175. USHORT tulos[15];                       /* HIGHSCORE-LISTAN TULOKSET    */
  176. USHORT sijoitus;                            /* SIJOITUS LISTALLA        */
  177. ULONG  clock;                               /* KELLOTAAJUUS             */
  178. UBYTE  SS            =   1;                 /* 1. VAI 2. KANAVA         */
  179. UBYTE  KIELI;                               /* KIELI PELIN AIKANA       */
  180. UBYTE  ALOITUSKIELI;                        /* ALOITUSKIELI             */
  181. UBYTE  FromWB        =   FALSE;             /* KÄYNNISTYS IKONISTA?     */
  182. UBYTE  SOUNDS        =   0;     /* 0=PÄÄLLÄ, 1=POIS, 2=POIS:EI PÄÄLLE!! */
  183.  
  184.  
  185.  
  186.  
  187. /***** PÄÄOHJELMA VENAA 'WAIT'ISSA JA OTTAA VASTAAN INTUITION-VIESTEJÄ **/
  188.  
  189. VOID main ( argc,argv)
  190. int argc;
  191. char *argv[];
  192. {
  193. struct IntuiMessage *msg = NULL;    /* VIESTIPOINTTERI              */
  194. SHORT  flagi;                       /* FALSE, KUN PELI LOPPUU       */
  195. ULONG  code;                        /* INTUITIONVIESTIN LUKUARVO    */
  196. SHORT  i;                           /* INDEKSILASKURI               */
  197.  
  198. if ( argc == 0 )    FromWB = TRUE;  /* KÄYNNISTYS WORKBENCHISTÄ     */
  199.  
  200. #if defined FEA_NOT_ENGLISH_GIFTWARE
  201.     ALOITUSKIELI = 0;                       /* ALOITUSKIELI = SUOMI */
  202. #else
  203.     ALOITUSKIELI = 1;                    /* ALOITUSKIELI = ENGLANTI */
  204. #endif
  205.  
  206. if ( argc > 0 )               /* ANNETTU PARAMETREJÄ KOMENTORIVILTÄ */
  207.     {
  208.     if (argv[1][0] == 's' || argv[1][0] == 'S' ||
  209.         argv[2][0] == 's' || argv[2][0] == 'S' )
  210.         {
  211.         SOUNDS = 2;                                /* SOUNDS ON/OFF */
  212.         }
  213.  
  214.     if (argv[1][0] > '0' && argv[1][0] < '3' )           /* KIELI ? */
  215.         {
  216.         ALOITUSKIELI = argv[1][0]-49;
  217.         }
  218.     if (argv[2][0] > '0' && argv[2][0] < '3' )
  219.         {
  220.         ALOITUSKIELI = argv[2][0]-49;
  221.         }
  222.     }
  223.  
  224. AIOptr1     = 0L;                   /* NOLLATAAN MUUTTUJAT, JOTTA   */
  225. AIOptr2     = 0L;                   /* TIEDETÄÄN SULKEAKO NE VAI EI */
  226. port1       = 0L;
  227. port2       = 0L;
  228. device1     = 1L;
  229. device2     = 1L;
  230.  
  231. for (i=0; i<SOUND_MAX; i++)         /* SAMOIN SAMPLEPOINTTERIT      */
  232.         {
  233.         sbase[i] = 0L;
  234.         }
  235.  
  236. OpenAll();                          /* AVATAAN KIRJASTOT JA GRAFIIKAT */
  237. RP = window->RPort;                 /* POINTTERI IKKUNAN RASTPORTTIIN */
  238. Initialize();                       /* ALUSTETAAN PELIKENTTÄ        */
  239.  
  240. if (SOUNDS == 0)                    /* SOUNDEJA EI OLE KIELLETTY    */
  241.     {
  242.     AvaaSoundit();                  /* LATAA SAMPLET LEVYLTÄ        */
  243.     VaraaKanavat();                 /* VARAA SOITTOKANAVAT          */
  244.     }
  245.  
  246. flagi=TRUE;
  247. while(flagi)                        /* KUNNES flagi == FALSE (LOPPUU) */
  248.     {
  249.     Wait ( 1L << window->UserPort->mp_SigBit); /* ODOTETAAN INT. VIESTIÄ */
  250.     while (msg=(struct IntuiMessage *)GetMsg(window->UserPort))
  251.         {                           /* LUETAAN VIESTEJÄ, KUNNES LOPPUVAT */
  252.         code=msg->Code;             /* VIESTIN KOODIARVO */
  253.         switch(msg->Class)
  254.             {
  255.             case MOUSEBUTTONS:
  256.                 if ( code == MENUDOWN )  /* JAKO HIIREN OIKEALLA NAPILLA */
  257.                     {
  258.                     Jako();
  259.                     }
  260.                 break;
  261.             case RAWKEY:
  262.                 if (pelitilanne == 1 && code < 3 && code > 0) 
  263.                     {
  264.                     MuutaKielta( (UBYTE)(code-1) );  /* 1, 2 tai 3    */
  265.                     }
  266.                 if ( code == 33 && SOUNDS == 0)      /* SOUNDS -> ON  */
  267.                     {
  268.                     SOUNDS = 1;
  269.                     }
  270.                 else if ( code == 33 && SOUNDS == 1) /* SOUNDS -> OFF  */
  271.                     {
  272.                     SOUNDS = 0;
  273.                     }
  274.                 if ( code == 16 )           /* Q - LOPETUS             */
  275.                     {
  276.                     flagi = FALSE;
  277.                     }
  278. #if defined FEA_NOT_ENGLISH_GIFTWARE
  279.                 if ( code == 95 )           /* HELP - TEKIJÖISTÄ       */
  280.                     {
  281.                     Aboutti();                  
  282.                     }
  283. #endif
  284.                 break;
  285.             case GADGETDOWN:                /* KÄSITELLÄÄN GADGET-ALAS */
  286.                 HandleDGad(msg);
  287.                 break;
  288.             case GADGETUP:                  /* KÄSITELLÄÄN GADGET-YLÖS */
  289.                 flagi=HandleUGad(msg);
  290.                 break;
  291.             default: break;
  292.             }
  293.         ReplyMsg((struct Message *)msg);    /* VASTATAAN VIESTEIHIN    */
  294.         }
  295.     }
  296. cleanExit(0);                               /* OHJELMAN NORMAALI LOPPU */
  297. }
  298.  
  299. /* END OF MAIN PROGRAM */
  300.  
  301.  
  302.  
  303.  
  304. /******* TÄMÄ FUNKTIO KÄSITTELEE GADGET-ALAS-TAPAUKSET ************/
  305.  
  306. VOID HandleDGad(m)
  307. struct IntuiMessage *m;
  308. {
  309. struct Gadget *g;           /* TÄHÄN SAADAAN SELVILLE GADGETIN TIEDOT */
  310. USHORT id;                  /* VARSINAINEN ID-MUUTTUJA */
  311. SHORT i, x, xx;
  312.  
  313. g  = (struct Gadget *)m->IAddress;              /* GAGETIN TIEDOT  */
  314. id = g->GadgetID;                               /* GAGETIN ID      */
  315.  
  316.  
  317. /**************************** PANOKSEN MUUTOS **************************/
  318.  
  319. if ( (id==50) || (id==13) )                     /* PANOKSEN MUUTOS */
  320.     {
  321.     if (tyhjennys==4)                           /* LISTA RUUDULLA  */
  322.         {
  323.         SetAPen(RP, 0);
  324.         RectFill(RP, 5, 32, 315, 198);          /* OTETAAN POIS    */
  325.         tyhjennys=1;
  326.         }
  327.     nytpanos++;                                 /* PANOS KASVAA    */
  328.     if ( (panokset[nytpanos] > (pelit+voitot)) || nytpanos==5)
  329.         {
  330.         nytpanos=0;                             /* ---> 1 mk       */
  331.         }
  332.     Sound(2, 175-nytpanos*15, 3);
  333.     PrinttaaPanos();                            /* PÄIVITÄ NÄYTTÖ  */
  334.     }
  335.  
  336.  
  337. /**************************** KORTTI PAINETTU **************************/
  338.  
  339. if ( id<6 )                                     /* KORTTI PAINETTU */
  340.     {
  341.     SetBPen(RP, 1);
  342.     xx=KORTTIX-2+(id)*KORTTIL+(id)*KORTTIVALI;
  343.     if (valittu[id]==0)
  344.         {
  345.         valittu[id]=1;
  346.         }
  347.     else 
  348.         {
  349.         valittu[id]=0;
  350.         }
  351.  
  352.     i=5;
  353.     x=0;
  354.     while(i--)
  355.     {
  356.     if (valittu[i] == 1)    /* VÄHINTÄÄN YKSI KORTTI VALITTU */
  357.         {
  358.         x=1;
  359.         }
  360.     }
  361.     if ( (x==1) && (pelitilanne == 2) )     /* JAKO-NAPPULA KÄYTÖSSÄ */
  362.         {
  363.         pelitilanne = 3;
  364.         GadgetitKondixeen();
  365.         }
  366.     if ( (x==0) && (pelitilanne == 3) )     /* JAKO-NAPPULA EI KÄYTÖSSÄ */
  367.         {
  368.         pelitilanne = 2;
  369.         GadgetitKondixeen();
  370.         }
  371.  
  372.     if (valittu[id]==1)             /* KORTTI EI OLLUT VALITTU */
  373.         {
  374.         Sound(0, 100, 3);
  375.         for (x=0; x<21; x+=2)                       
  376.             {
  377.             WaitTOF();
  378.             BltBitMapRastPort(&bitMap, 264, KIELI*25+104-x, RP, xx+2, 199, 49, x+1, 0xC0);
  379.             }
  380.         }
  381.     else                            /* KORTTI OLI VALITTU */
  382.         {
  383.         Sound(1, 120, 3);
  384.         for(x=0; x<21; x+=2)
  385.             {
  386.             WaitTOF();
  387.             ScrollRaster(RP, 0, -2, xx+2, 203, xx+50, 223); 
  388.             }
  389.         }
  390.     SetBPen(RP, 0);
  391.     }
  392.  
  393. }   /* END OF HandleDGad() */
  394.  
  395.  
  396.  
  397.  
  398. /*********** TÄMÄ FUNKTIO KÄSITTELEE GADGET-YLÖS-TAPAUKSET ***************/
  399.  
  400. SHORT HandleUGad(m)
  401. struct IntuiMessage *m;
  402. {
  403. struct Gadget *g;           /* TÄHÄN SAADAAN SELVILLE GADGETIN TIEDOT */
  404. USHORT id;                  /* VARSINAINEN ID-MUUTTUJA  */
  405. SHORT  retval = TRUE;       /* PALUUARVO                */
  406. SHORT  i;                   /* LASKURI                  */
  407. LONG   kirjoitettuja;       /* TIEDOSTOMERKKIEN LASKURI */
  408.  
  409. g  = (struct Gadget *)m->IAddress;    /* GAGETIN TIEDOT */
  410. id = g->GadgetID;                     /* GAGETIN ID     */
  411.  
  412.  
  413. /******************************* LOPETUS ********************************/
  414.  
  415. if ( id == 99 )                         /* LOPETUS !!! */
  416.     {
  417.     retval = FALSE;
  418.     }
  419.  
  420.  
  421. /*********************** JAKO-NAPPULA NOSTETTU ***************************/
  422.  
  423. if (id == 11)                   /* JAKO */
  424.     {
  425.     Jako(); 
  426.     }
  427.  
  428.  
  429. /***************** VOITONMAKSU-NAPPULA NOSTETTU * pelitilanne == 1 ******/
  430.  
  431. if ( ( (id==12) || (id==51) ) && (pelitilanne==1) )
  432.     {
  433.     if (tyhjennys==3)
  434.         {
  435.         PuhdistaAlapalkki();                    /* PALKKI PUNAINEN   */
  436.         }
  437.     if (tyhjennys!=4)                           /* LISTA EI RUUDUSSA */
  438.         {
  439.         SetAPen(RP, 0);
  440.         RectFill(RP, 10, 32, 310, 198);
  441.         }
  442.     if (voitot>tulos[14])                       /* HIGHSCORE-LISTA   */
  443.         {
  444.         pelitilanne = 7;
  445.         GadgetitKondixeen();
  446.         ShadowText(RP, 22, 47, 5, 4, SekaTextit[KIELI]);
  447.         i=0;
  448.         while(tulos[i]>=voitot)     /* KO. TULOKSEEN SAAKKA */
  449.             {
  450.             sprintf(stringi, "%s%d.  %s", (i<9) ? " " : "", i+1, lista[i]);
  451.             ShadowText(RP, 22, (SHORT)(63+i*9), 10, 8, stringi);
  452.             i++;
  453.             }
  454.         sprintf(stringi, "%s%d.                          %5d",
  455.              (i<9) ? " " : "", i+1, voitot);
  456.         ShadowText(RP, 22, (SHORT)(63+i*9), 16, 5, stringi);
  457.         sijoitus=i+1;
  458.         i++;
  459.         while(i<15)                 /* KO. TULOKSESTA ETEENPÄIN */
  460.             {
  461.             sprintf(stringi, "%s%d.  %s", (i<9) ? " " : "", i+1, lista[i-1]);
  462.             ShadowText(RP, 22, (SHORT)(63+i*9), 10, 8, stringi);
  463.             i++;
  464.             }
  465.  
  466.         i=14;
  467.         while(i>(sijoitus-1))       /* ETSITÄÄN TULOKSEN KOHTA */
  468.             {
  469.             strcpy(lista[i], lista[i-1]);
  470.             tulos[i]=tulos[i-1];
  471.             i--;
  472.             }
  473.  
  474.         ColorSquare(RP, 144, 203, 161, 16, 8);      /* NIMILOOTA */
  475.         SetAPen(RP, 0);
  476.         RectFill(RP, 147, 206, 302, 216); 
  477.         ShadowText(RP, 12, 215, 9, 4, SekaTextit[3+KIELI]);
  478.         ActivateGadget(&Jono, window, NULL);
  479.         }
  480.     else
  481.         {
  482.         if (tyhjennys!=4)
  483.             {
  484.             ShadowText(RP, 22, 47, 28, 26, SekaTextit[6+KIELI]);
  485.             for (i=0; i<15; i++)
  486.                 {
  487.                 sprintf(stringi, "%s%d.  %s", (i<9) ? " " : "", i+1, lista[i]);
  488.                 ShadowText(RP, 22, (SHORT)(63+i*9), 16, 5, stringi);
  489.                 }
  490.             tyhjennys=4;
  491.             }
  492.         }
  493.     }
  494.  
  495.  
  496. /*********** VOITONMAKSU-NAPPULA NOSTETTU * pelitilanne == 5 ************/
  497.  
  498. if ( ( (id==12) || (id==51) ) && (pelitilanne==5) )
  499.     {
  500.     sprintf(stringi, "%5ld", voitot);
  501.     TextText(RP, 260, 19, 4, stringi );
  502.     if (tyhjennys==2)
  503.         {
  504.         sprintf(stringi, "%s  %4d", voittonimet[8*KIELI+nytvoitto], voittosumma);
  505.         PlainText(RP, 147, (SHORT)(45+nytvoitto*9), 7, 0, stringi );
  506.         }
  507.     KilistysAAYY();
  508.     if (tuplavoitto==voittosumma)
  509.         {
  510.         tyhjennys = 2;
  511.         }
  512.     else
  513.         {
  514.         tyhjennys = 3;
  515.         }
  516.     PuhdistaAlapalkki();
  517.     pelitilanne = 1;
  518.     GadgetitKondixeen();
  519.     KatsoRahaTilanne();
  520.     }
  521.  
  522.  
  523. /******************* PELIT-LAATIKKOA PAINETTU ***************************/
  524.  
  525. if (id==49)                             /* PELIT */
  526.     {
  527.     pelit = ALKUMARKAT;
  528.     nytpanos = ALKUPANOS;
  529.     KatsoRahaTilanne();
  530.     TulostaVoittoluokat();
  531.     PrinttaaPanos();
  532.     PrinttaaPelitVoitot();
  533.     VaritRuutuun(0);                    /* NORMAALIT VÄRIT */
  534.     pelitilanne = 1;        
  535.     GadgetitKondixeen();
  536.     }
  537.  
  538.  
  539. /********************* TUPLAUS-NAPPULA NOSTETTU *************************/
  540.  
  541. if ( id==16 && pelitilanne==5 )     /* TUPLAUS */
  542.     {
  543.     pelitilanne = 6;                /* TUPLAUSGADGETTI POIS PÄÄLTÄ */
  544.     GadgetitKondixeen();
  545.  
  546.     if (tyhjennys==3)               /* VAIN YKSI KORTTI PÖYDÄLLÄ */
  547.         {
  548.         KortitPakkaan();
  549.         }
  550.     else                            /* VIISI KORTTIA PÖYDÄLLÄ */
  551.         {
  552.         valittu[0]=0;
  553.         valittu[1]=0;
  554.         valittu[2]=0;
  555.         valittu[3]=0;
  556.         valittu[4]=0;       
  557.         KortitKasaan();
  558.         }
  559.     SetAPen(RP, 0);
  560.     RectFill(RP, KORTTIX-1, KORTTIY-1, 315, KORTTIY+KORTTIK+1); 
  561.     BltBitMapRastPort(&bitMap, 263, 161, RP, KORTTIX+2*KORTTIVALI+2*KORTTIL-1, KORTTIY-1, 51, 79, 0xC0);
  562.  
  563.     SetAPen(RP, 3);
  564.     RectFill(RP, 0, 199, 319, 223);             /* ALAPALKKI PUNAISEKSI */
  565.     tuplavoitto *= 2;
  566.     ColorSquare(RP, 70, 202, 36, 18, 8);        /* ALALOOTA */
  567.     sprintf(stringi, SekaTextit[9+KIELI]);      /* SUURI / PIENI */
  568.     ShadowText(RP,  16, 215, 1, 4, stringi );
  569.     KilistysAY();
  570.  
  571.     if (tuplavoitto > 100)
  572.         {
  573.         Sound(9, 100, 3);
  574.         Delay(100);
  575.         }
  576.  
  577.     i = Satunnaisluku(0, (SHORT)(51+jokerimukana) );        /* ARVONTA */
  578.     kortit[57] = kortit[i];
  579.     DeKoodaa();
  580.     }
  581.  
  582.  
  583. /**************** PIENI- / SUURI-NAPPULA NOSTETTU *********************/
  584.  
  585. if ( (id==15 || id==14) && pelitilanne == 6 )       /* PIENI / SUURI */
  586.     {
  587.     DeKoodaa();                 
  588.     KortinGrafiikkaTalteen(2);
  589.     KortinGrafiikka(2);     
  590.     tyhjennys=3;
  591.  
  592.     /* ARVAUS OSUI OIKEAAN!!!!!!!!!!!!!!!! */
  593.     if ( ( (id==15) && kortit[67]<7 ) || ( (id==14) && kortit[67]>7 ) || kortit[67]==15 )
  594.         {
  595.         /***** VOITTO TARPEEKSI SUURI -> YLÖS ******/
  596.         if (tuplavoitto>100)
  597.             {
  598.             Delay(10);
  599.             Sound(10, 100, 3);
  600.             Delay(127);
  601.             KilistysAAYY();
  602.             PuhdistaAlapalkki();
  603.             pelitilanne = 1;
  604.             GadgetitKondixeen();
  605.             }
  606.         else    /* VOITTO EI HÄIKÄISSYT SUURUUDELLAAN -> TUPLAUS */
  607.             {
  608.             pelitilanne = 5;
  609.             GadgetitKondixeen();
  610.             SetAPen(RP, 3);
  611.             RectFill(RP, 0, 199, 319, 223); /* ALAPALKKI PUNAISEKSI */
  612.             ColorSquare(RP, 70, 202, 36, 18, 8);        /* ALALOOTA */
  613.             sprintf(stringi, SekaTextit[12+KIELI]);
  614.             ShadowText(RP,  16, 215, 1, 4, stringi );
  615.             Sound(4, 100, 3);
  616.             sprintf(stringi, "%3d", tuplavoitto);
  617.             TextText(RP, 77, 215, 4, stringi );
  618.             }
  619.         }   /* if nytpanos ... */
  620.  
  621.     else                        /* ARVAUS EPÄONNISTUI -> PELITILANNE = 1 */
  622.         {
  623.         SetAPen(RP, 3);
  624.         RectFill(RP, 0, 199, 319, 223);         /* ALAPALKKI PUNAISEKSI */
  625.         ColorSquare(RP, 70, 202, 36, 18, 8);        /* ALALOOTA */
  626.         ShadowText(RP,  16, 215, 1, 4, SekaTextit[15+KIELI] );
  627.         TextText(RP, 77, 215, 4, "  0" );
  628.         Sound(5, 100, 3);
  629.         pelitilanne = 1;
  630.         GadgetitKondixeen();
  631.         KatsoRahaTilanne();
  632.         }
  633.     }       /* if id== ...     */
  634.  
  635.  
  636. /******************* STRING-GADGET KUITATTU ENTERILLÄ *******************/
  637.  
  638. if (id==20)
  639.     {
  640.     strcpy(stringi, JonoPuskuri);
  641.     for (i=strlen(stringi); i<23; i++)
  642.         {
  643.         stringi[i]=' ';
  644.         }
  645.     stringi[i]='\0';
  646.     tulos[sijoitus-1]=voitot;
  647.     sprintf(lista[sijoitus-1], "%s %5d", stringi, voitot);
  648.     sprintf(stringi, "%s%d.  %s", (sijoitus<10) ? " " : "", sijoitus, lista[sijoitus-1]);
  649.     ShadowText(RP, 22, (SHORT)(63+(sijoitus-1)*9), 16, 5, stringi);     
  650.     voitot=0;
  651.  
  652.     infile = (struct FileHandle *)Open("POKERI.HIGHSCORE", MODE_OLDFILE);
  653.     if ( infile != 0)
  654.         {
  655.         for(i=0; i<15; i++)
  656.             {
  657.             kirjoitettuja=Write((BPTR)infile, lista[i], 30);
  658.             }
  659.         Close((BPTR)infile);
  660.         }
  661.     else if ((infile = (struct FileHandle *)
  662.             Open("POKERI.HIGHSCORE", MODE_NEWFILE)) != 0)
  663.         {
  664.         for(i=0; i<15; i++)
  665.             {
  666.             kirjoitettuja=Write((BPTR)infile, lista[i], 30);
  667.             }
  668.         Close((BPTR)infile);
  669.         }
  670.  
  671.     PuhdistaAlapalkki();
  672.     pelitilanne = 1;
  673.     GadgetitKondixeen();
  674.     tyhjennys=4;
  675.     PrinttaaPelitVoitot();
  676.     KatsoRahaTilanne();
  677.     }
  678.  
  679. return(retval);
  680.  
  681. }   /* END OF HandleUGad() */
  682.  
  683.  
  684.  
  685.  
  686. /****** FUNKTIO PIIRTÄÄ LAATIKON KOLMELLA VÄRILLÄ, MYÖS SISÄKEHYKSEN ******/
  687. /*  x ja y = laatikon vasemman yläkulman koordinaatit
  688.     width  = laatikon leveys    
  689.     height = laatikon korkeus
  690.     vari   = ensimmäisen palettivärin numero (eli vaalein savy) */
  691.  
  692. VOID ColorSquare(rp, x, y, width, height, vari)
  693. struct RastPort *rp;
  694. SHORT  x, y, width, height, vari;
  695. {
  696. UBYTE oldapen;
  697.  
  698. oldapen = rp->FgPen;
  699. SetAPen (rp, vari);             /* VASEN- JA YLÄREUNA VAALEALLA */
  700. Move    (rp, x+width, y);
  701. Draw    (rp, x, y);
  702. Draw    (rp, x, y+height);
  703.  
  704. SetAPen (rp, vari+1);           /* SISUSTA KESKIVÄRILLÄ */
  705. RectFill(rp, x+1, y+1, x+width-1, y+height-1 );
  706.  
  707. SetAPen (rp, vari);             /* KEHYS VAALEALLA */
  708. RectFill(rp, x+2, y+2, x+width-2, y+height-2 );
  709.  
  710. SetAPen (rp, vari+1);           /* SISUSTA KESKIVÄRILLÄ */
  711. RectFill(rp, x+3, y+3, x+width-3, y+height-3 );
  712.     
  713. SetAPen (rp, vari+2);           /* OIKEA- JA ALAREUNA TUMMALLA */
  714. Move    (rp, x+1, y+height);
  715. Draw    (rp, x+width, y+height);
  716. Draw    (rp, x+width, y);
  717.  
  718. SetAPen (rp, oldapen);
  719. }
  720.  
  721.  
  722.  
  723.  
  724. /************* PUHDISTAA ALAPALKIN JA TYHJÄÄ VALINNAT **************/
  725.  
  726. VOID PuhdistaAlapalkki()
  727. {
  728. SHORT i, x;
  729.  
  730. SetBPen(RP, 1);
  731. for(i=0; i<5; i++)
  732.     {
  733.     valittu[i] = 0;
  734.     }
  735.  
  736. for(x=0; x<25; x++)
  737.     {
  738.     WaitTOF();
  739.     ScrollRaster(RP, 0, -1, 0, 199, 319, 223); 
  740.     }
  741. }
  742.  
  743.  
  744.  
  745.  
  746. /************** FUNKTIO TULOSTAA VARJOSTETTUA TEKSTIÄ ***************/
  747. /*  x ja y = tekstin vasemman yläkulman koordinaatit
  748.     vari1  = pohjaväri
  749.     vari2  = piirtoväri
  750.     text   = tekstin osoite */
  751.  
  752. VOID ShadowText(rp, x, y, vari1, vari2, text)
  753. struct RastPort *rp;
  754. SHORT  x, y, vari1, vari2;
  755. BYTE *text;
  756. {
  757. UBYTE oldapen;
  758.  
  759. oldapen = rp->FgPen;
  760. SetAPen (rp, vari1);                /* ASETTAA PIIRTOVARIN */
  761. Move    (rp, x, y);                 /* SIIRTÄÄ KYNÄÄ       */ 
  762. Text    (rp, text, strlen(text));   /* TULOSTAA  TEKSTIN   */
  763. SetAPen (rp, vari2);
  764. Move    (rp, x-1, y-1);
  765. Text    (rp, text, strlen(text));   
  766. SetAPen (rp, oldapen);
  767. }
  768.  
  769.  
  770.  
  771.  
  772. /************** FUNKTIO TULOSTAA TAVALLISTA TEKSTIÄ ***************/
  773. /*  x ja y = tekstin vasemman yläkulman koordinaatit
  774.     vari2  = piirtoväri
  775.     text   = tekstin osoite */
  776.  
  777. VOID PlainText(rp, x, y, vari1, vari2, text)
  778. struct RastPort *rp;
  779. SHORT x, y, vari1, vari2;
  780. BYTE *text;
  781. {
  782. UBYTE oldapen;
  783. UBYTE oldbpen;
  784.  
  785. oldapen = rp->FgPen;
  786. oldbpen = rp->BgPen;
  787. SetDrMd (rp, JAM2);                 /* ASETTAA PIIRTOMOODIN */
  788. SetAPen (rp, vari1);                /* ASETTAA PIIRTOVARIN  */
  789. SetBPen (rp, vari2);                /* ASETTAA TAUSTAVÄRIN  */
  790. Move    (rp, x-1, y-1);             /* SIIRTÄÄ KYNÄÄ        */ 
  791. Text    (rp, text, strlen(text));   /* TULOSTAA  TEKSTIN    */
  792. SetDrMd (rp, JAM1);                 /* PALAUTTAA PIIRTOMOODIN */
  793. SetAPen (rp, oldapen);
  794. SetBPen (rp, oldbpen);
  795. }
  796.  
  797.  
  798.  
  799.  
  800. /*********** TULOSTAA TEKSTIÄ, SINISELLE POHJALLE JAM2:LLA **********/
  801. /*  x ja y = tekstin vasemman yläkulman koordinaatit
  802.     vari   = piirtoväri
  803.     text   = tekstin osoite */
  804.  
  805. VOID TextText(rp, x, y, vari, text)
  806. struct RastPort *rp;
  807. SHORT x, y, vari;
  808. BYTE *text;
  809. {
  810. UBYTE oldapen;
  811. UBYTE oldbpen;
  812.  
  813. oldapen = rp->FgPen;                    /* VANHA PIIRTOVÄRI       */
  814. oldbpen = rp->BgPen;                    /* VANHA TAUSTAVÄRI       */
  815. SetFont (rp, textFont);                 /* ASETTAA PIIRTOFONTIN   */
  816. SetBPen (rp, 9);                        /* ASETTAA TAUSTAVÄRIN    */
  817. SetDrMd (rp, JAM2);                     /* ASETTAA PIIRTOMOODIN   */
  818. SetAPen (rp, vari);                     /* ASETTAA PIIRTOVÄRIN    */
  819. Move    (rp, x, y);                     /* SIIRTÄÄ KYNÄN          */
  820. Text    (rp, text, strlen(text));       /* TULOSTAA TEKSTIN       */
  821. SetBPen (rp, 0);                        /* PALAUTTAA TAUSTAVÄRIN  */
  822. SetDrMd (rp, JAM1);                     /* PALAUTTAA PIIRTOMOODIN */
  823. SetFont (rp, oldTextFont);              /* PALAUTTAA PIIRTOFONTIN */
  824. SetAPen (rp, oldapen);                  /* PALAUTTAA PIIRTOVÄRIN  */
  825. SetBPen (rp, oldbpen);                  /* PALAUTTAA TAUSTAVÄRIN  */
  826. }
  827.  
  828.  
  829.  
  830.  
  831. /*********** TULOSTAA PELIT JA VOITOT KULLOISELLA KIELELLÄ **************/
  832.  
  833. VOID  TekstiPelitVoitot(kieli)
  834. UBYTE kieli;
  835. {
  836. UBYTE oldapen;
  837.  
  838. oldapen = RP->FgPen;
  839. SetAPen(RP, 9);
  840. RectFill(RP, 19, 10, 87, 20);
  841. ShadowText(RP, 21, 19, 1, 4, Peitot[KIELI*2]);      /* PELIT */
  842. SetAPen(RP, 9);
  843. RectFill(RP, 198, 10, 255, 20);
  844. ShadowText(RP, 200, 19, 1, 4, Peitot[KIELI*2+1]);   /* VOITOT */
  845. SetAPen(RP, oldapen);
  846. }
  847.  
  848.  
  849.  
  850.  
  851. /********* TULOSTAA KORTIT PÖYTÄÄN *************************/
  852.  
  853. VOID TulostaKortit()
  854. {
  855. SHORT i;
  856.  
  857. SetAPen(RP, 0);                     /* POISTETAAN PAKKA JA TEKSTIT */
  858. RectFill(RP, 10, 33, 300, KORTTIY-2);
  859.  
  860. DeKoodaa();                         /* DEKOODATAAN KORTIT */
  861.  
  862. i=0;
  863. while(i<5)                          /* PIIRRETÄÄN VIISI KORTTIA */
  864.     {
  865.     WaitTOF();
  866.     Sound(7, 90, 3);
  867.     BltBitMapRastPort(&bitMap, 263, 161,
  868.         RP, KORTTIX+i*KORTTIVALI+i*KORTTIL-1, 35, 51, 79, 0xC0);
  869.     Delay(5);
  870.  
  871.     WaitTOF();
  872.     BltBitMapRastPort(&bitMap, 263, 161,
  873.         RP, KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1, 51, 79, 0xC0);
  874.     Delay(8);
  875.  
  876.     SetAPen(RP, 0);
  877.     RectFill(RP, KORTTIX+i*KORTTIVALI+i*KORTTIL-1,
  878.         35, KORTTIX+i*KORTTIVALI+i*KORTTIL+KORTTIL-1, KORTTIY-2);
  879.     i++;
  880.     }
  881.  
  882. i=0;
  883. while(i<5)                          /* KÄÄNNETÄÄN VIISI KORTTIA */
  884.     {
  885.     Sound(7, 90, 3);
  886.     KortinGrafiikkaTalteen(i);
  887.     KortinGrafiikka(i);
  888.     Delay(1);
  889.     i++;
  890.     }
  891.  
  892. PiirraPakka();
  893. TulostaVoittoluokat();
  894. }   
  895.  
  896.  
  897.  
  898.  
  899. /************ TULOSTAA KORTIT PÖYTÄÄN JA KÄÄNTÄÄ NE HETI **************/
  900.  
  901. VOID TulostaKortit2()
  902. {
  903. SHORT i, x, y;
  904. SHORT index;
  905.  
  906. SetAPen(RP, 0);                     /* POISTETAAN PAKKA JA TEKSTIT */
  907. RectFill(RP, 10, 33, 300, KORTTIY-2);
  908.  
  909. DeKoodaa();                         /* DEKOODATAAN KORTIT */
  910.  
  911. i=5;
  912. x=0;
  913. index=0;
  914. while(i--)
  915.     {
  916.     if(valittu[i]==1)
  917.         {
  918.         x++;        /* VALITTUJEN LUKUMÄÄRÄ */
  919.         }
  920.     }
  921. i=0;
  922. while(i<5)                          /* PIIRRETÄÄN VIISI KORTTIA */
  923.     {
  924.     if (valittu[i]==0)              /* PIIRRETÄÄNKÖ KORTTI? */
  925.         {
  926.         WaitTOF();
  927.         Sound(7, 90, 3);
  928.         BltBitMapRastPort(&bitMap, 263, 161,
  929.             RP, KORTTIX+i*KORTTIVALI+i*KORTTIL-1, 35, 51, 79, 0xC0);
  930.         Delay(5);
  931.         WaitTOF();
  932.         BltBitMapRastPort(&bitMap, 263, 161,
  933.             RP, KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1, 51, 79, 0xC0);
  934.         Delay(8);
  935.         index++;
  936.         SetAPen(RP, 0);
  937.         RectFill(RP, KORTTIX+i*KORTTIVALI+i*KORTTIL-1,
  938.             35, KORTTIX+i*KORTTIVALI+i*KORTTIL+KORTTIL-1, KORTTIY-2);
  939.         KortinGrafiikkaTalteen(i);
  940.         if ( index == 5-x )
  941.             {
  942.             PiirraPakka();
  943.  
  944. /*          SetAPen(RP, 0);
  945.             for (y=0; y<240; y+=4)
  946.                 {
  947.                 WaitTOF();
  948.                 BltBitMapRastPort(&bitMap, 243, 161, RP,
  949.                     4+y, 35, 71, 79, 0xC0);
  950.                 Delay(1);
  951.                 }
  952. */
  953.             for (y=1; y<4; y++)                 /* PIHISTETÄÄN!! */
  954.                 {
  955.                 WaitTOF();
  956.                 BltBitMapRastPort(&bitMap, 263, 161, RP,
  957.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y,51,79,0xC0);
  958.                 BltBitMapRastPort(&cardbitMap, 0, y-1, RP,
  959.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y-1,51,1,0xC0);
  960.                 Delay(8);
  961.                 }
  962.             for (y=4; y<15; y++)
  963.                 {
  964.                 WaitTOF();
  965.                 BltBitMapRastPort(&bitMap, 263, 161, RP,
  966.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y,51,82-y,0xC0);
  967.                 BltBitMapRastPort(&cardbitMap, 0, y-1, RP,
  968.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y-1,51,1,0xC0);
  969.                 Delay(8);
  970.                 }
  971.             for (y=15; y<29; y++)
  972.                 {
  973.                 WaitTOF();
  974.                 BltBitMapRastPort(&bitMap, 263, 161, RP,
  975.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y,51,82-y,0xC0);
  976.                 BltBitMapRastPort(&cardbitMap, 0, y-1, RP,
  977.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y-1,51,1,0xC0);
  978.                 }
  979.             for (y=29; y<82; y+=2)
  980.                 {
  981.                 WaitTOF();
  982.                 BltBitMapRastPort(&bitMap, 263, 161, RP,
  983.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y,51,82-y,0xC0);
  984.                 BltBitMapRastPort(&cardbitMap, 0, y-1, RP,
  985.                   KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1+y-1,51,2,0xC0);
  986.                 }
  987.             }
  988.         else
  989.             {
  990.             KortinGrafiikka(i);
  991.             }
  992.         }
  993.     i++;
  994.     }
  995.  
  996. if ( x == 5 )
  997.     {
  998.     PiirraPakka();
  999.     }
  1000.  
  1001. TulostaVoittoluokat();
  1002. }   
  1003.  
  1004.  
  1005.  
  1006.  
  1007. /**************** KÄÄNTÄÄ VALITSEMATTOMAT KORTIT NURIN ******************/
  1008.  
  1009. VOID TaustaKortit()
  1010. {
  1011. SHORT i;
  1012.  
  1013. i=0;
  1014. while(i<5)
  1015.     {
  1016.     WaitTOF();
  1017.     if (valittu[i]==0)      /* KÄÄNNETÄÄNKÖ KORTTI? */
  1018.         {
  1019.         BltBitMapRastPort(&bitMap, 263, 161, RP,
  1020.             KORTTIX+i*KORTTIVALI+i*KORTTIL-1, KORTTIY-1, 51, 79, 0xC0);
  1021.         }
  1022.     i++;
  1023.     }
  1024. }   
  1025.  
  1026.  
  1027.  
  1028.  
  1029. /*************** POISTAA VALITSEMATTOMAT KORTIT PÖYDÄLTÄ ***************/
  1030.  
  1031. VOID KortitPois()
  1032. {
  1033. SHORT i, j;
  1034.  
  1035. TaustaKortit();
  1036. Delay(5);
  1037.  
  1038. for (i=0; i<5; i++)
  1039.     {
  1040.     WaitTOF();
  1041.     if (valittu[i]==0)          /* POISTETAANKO KORTTI? */
  1042.         {
  1043.         Sound(6, 100, 3);
  1044.         for (j=0; j<21; j++)
  1045.             {
  1046.             ScrollRaster(RP, 0, -4, KORTTIX+i*KORTTIVALI+i*KORTTIL-1,
  1047.                 KORTTIY-1, KORTTIX+i*KORTTIVALI+i*KORTTIL+49, KORTTIY+80); 
  1048.             WaitTOF();
  1049.             }
  1050.         }
  1051.     }
  1052. }   
  1053.  
  1054.  
  1055.  
  1056.  
  1057. /************* KERÄÄ PÖYDÄLLÄ LOJUVAT KORTIT KESKELLE KASAAN ************/
  1058.  
  1059. VOID KortitKasaan()
  1060. {
  1061. SHORT i;
  1062.  
  1063. TaustaKortit();     /* KÄÄNNETÄÄN ENSIN */
  1064. Delay(5);
  1065.  
  1066. i=0;
  1067. while(i<12)         /* KERÄTÄÄN */
  1068.     {
  1069.     WaitTOF();
  1070.     ClipBlit(RP, KORTTIX-KORTTIVALI-3+i*KORTTIVALI, KORTTIY-1, RP,
  1071.         KORTTIX-3+i*KORTTIVALI, KORTTIY-1, 64, 79, 0xC0);
  1072.     WaitTOF();
  1073.     ClipBlit(RP, 256-KORTTIVALI*i, KORTTIY-1, RP,
  1074.         246-KORTTIVALI*i, KORTTIY-1, 61, 79, 0xC0);
  1075.     i++;
  1076.     }
  1077. KortitPakkaan();    /* JA YLÖS PAKKAAN */
  1078. }   
  1079.  
  1080.  
  1081.  
  1082.  
  1083. /****************** HEITTÄÄ KORTIT KESKELTÄ PAKKAAN **********************/
  1084.  
  1085. VOID KortitPakkaan()
  1086. {
  1087. SHORT i;
  1088. SHORT x=135, y=118;
  1089.  
  1090. SetAPen (RP, 0);                    /* ENSIN ESISIIRTO KESKELLÄ */
  1091. RectFill(RP, 145, 33, 300, 116);
  1092. WaitTOF();
  1093. BltBitMapRastPort(&bitMap, 263, 161, RP,
  1094.     KORTTIX+2*KORTTIVALI+2*KORTTIL-1, KORTTIY-1, 51, 79, 0xC0);
  1095. ClipBlit(RP, x, y, RP, x-2, y-4, 55, 80, 0xC0);
  1096. RectFill(RP, x-2, y+71, x+60, y+80);
  1097.  
  1098. x=133;                              /* VARSINAINEN SIIRTO */
  1099. y=112;  
  1100. Sound(7, 100, 3);
  1101. for(i=0; i<10; i++)
  1102.     {
  1103.     WaitTOF();
  1104.     ClipBlit(RP, x-i*12, y-i*8, RP, (x-12)-i*12, (y-8)-i*8, 63, 87, 0xC0);
  1105.     }
  1106.  
  1107. PiirraPakka();                      /* PAKKA YLHÄÄLLÄ KUNTOON */
  1108. }   
  1109.  
  1110.  
  1111.  
  1112.  
  1113. /******************* TULOSTAA VOITTOLUOKAT JA VOITOT **********************/
  1114.  
  1115. VOID TulostaVoittoluokat()
  1116. {
  1117. SHORT i;
  1118.  
  1119. SetAPen(RP, 0);
  1120. if (tyhjennys==4)
  1121.     {
  1122.     RectFill(RP, 5, 32, 317, 197);      /* RUUTU TYHJÄKSI */
  1123.     }
  1124.  
  1125. if (nytpanos>1)             /* MUKANA 'VIITOSET' */
  1126.     {
  1127.     sprintf(stringi, "%s  %4d", voittonimet[KIELI*8],
  1128.         voittosummat[nytpanos][0]);
  1129.     PlainText(RP, 147, 45, 7, 0, stringi );
  1130.     }
  1131. else 
  1132.     {
  1133.     RectFill(RP, 145, 37, 300, 45); 
  1134.     }
  1135.  
  1136. for (i=1; i<8; i++)         /* TULOSTETAAN VOITOT */
  1137.     {
  1138.     sprintf(stringi, "%s  %4d", voittonimet[i+KIELI*8],
  1139.         voittosummat[nytpanos][i]);
  1140.     PlainText(RP, 147, (SHORT)(45+i*9), 7, 0, stringi );
  1141.     }
  1142. }
  1143.  
  1144.  
  1145.  
  1146.  
  1147. /******* HAKEE KORTIN GRAFIIKAN BITTIKARTASTA MÄÄRÄTTYYN PAIKKAAN *******/
  1148. /*  i = numero 0..4 maskeeraa kortin paikkaa näytöllä */ 
  1149.  
  1150. VOID KortinGrafiikka(i)
  1151. SHORT i;
  1152. {
  1153.  
  1154. BltBitMapRastPort(&cardbitMap, 0, 0, RP,
  1155.     (SHORT)(KORTTIX+i*KORTTIVALI+i*KORTTIL-1), KORTTIY-1, 51, 79, 0xC0 );
  1156. }
  1157.  
  1158.  
  1159.  
  1160.  
  1161. /************* TULOSTAA KORTIN GRAFIIKAN PIILOBITTIKARTTAAN **************/
  1162.  
  1163. VOID KortinGrafiikkaTalteen(i)
  1164. SHORT i;
  1165. {
  1166. SHORT kkk, maa;
  1167.  
  1168. SetAPen(&cardRP, 4);
  1169. RectFill(&cardRP, 0, 0, KORTTIL, KORTTIK );
  1170.  
  1171. if(kortit[55+i]==255)
  1172.     {
  1173.     BltBitMapRastPort(&bitMap, 263, 3, &cardRP, 0, 0, 51, 79, 0xC0 );
  1174.     }
  1175. else
  1176.     {
  1177.     if(kortit[60+i]==128)       /* PATA */
  1178.         maa=0;
  1179.     if(kortit[60+i]==64)        /* HERTTA */
  1180.         maa=1;
  1181.     if(kortit[60+i]==32)        /* RISTI */
  1182.         maa=2;
  1183.     if(kortit[60+i]==16)        /* RUUTU */
  1184.         maa=3;
  1185.  
  1186.     kkk = kortit[65+i]-1;
  1187.     BltBitMapRastPort(&bitMap, 3+kkk*11, ((maa==0)||(maa==2))?1:12,
  1188.         &cardRP, 2, 2, 10, 11, 0xC0 );
  1189.     BltBitMapRastPort(&bitMap, 220+maa*10,  4, &cardRP, 1, 13, 11, 12, 0xC0 );
  1190.     BltBitMapRastPort(&bitMap, 220+maa*10, 15, &cardRP, 39, 54, 11, 12, 0xC0 );
  1191.     BltBitMapRastPort(&bitMap, 3+kkk*11, ((maa==0)||(maa==2))?23:35,
  1192.         &cardRP, 39, 65, 10, 11, 0xC0 );
  1193.  
  1194.     if (kkk<10)
  1195.         {
  1196.         BltBitMapRastPort(&bitMap, 2+kkk*24, 51+maa*50, &cardRP, 13, 14, 25, 51, 0xC0);
  1197.         }
  1198.     else
  1199.         {
  1200.         BltBitMapRastPort(&bitMap, 146+(kkk-10)*24, 1, &cardRP, 13, 14, 25, 51, 0xC0);
  1201.         }
  1202.     }   /* else kortit ... */
  1203. }
  1204.  
  1205.  
  1206.  
  1207.  
  1208. /*********************** PRINTTAA PANOKSEN KONDIKSEEN ****************/ 
  1209.  
  1210. VOID PrinttaaPanos()
  1211. {
  1212.  
  1213. SetAPen(RP, 7);
  1214. sprintf(stringi, "%d", panokset[nytpanos]);
  1215. RectFill(RP, 140, 10, 153, 19);
  1216. ShadowText(RP, (SHORT)((strlen(stringi)==2)?140:144), 18, 18, 19, stringi);
  1217.         
  1218. if (nytpanos>1)                         /* ONKO PANOS >= 3 mk ? */
  1219.     {
  1220.     jokerimukana = 1;
  1221.     }
  1222. else                                    /* PANOS == 1 tai 2     */
  1223.     {
  1224.     OtaPoisJokeri();
  1225.     }
  1226.  
  1227. TulostaVoittoluokat();
  1228. }
  1229.  
  1230.  
  1231.  
  1232.  
  1233. /***************** TÄMÄ ALIOHJELMA TARKISTAA VOITOT *******************/
  1234.  
  1235. SHORT TarkistaVoitot()
  1236. {
  1237. SHORT i, j, voittonumero=8;
  1238. UBYTE apusuora1=0, apusuora2=0, apusuora3=0, jokeri=0, pari=0;
  1239. UBYTE kolmoset=0, apuvari=0, vari=0, suora=0; 
  1240.  
  1241. /* LAJITELLAAN TAULUKON kortit[54-59] ALKIOT, PIENIN ENSIN */
  1242.  
  1243. for (i=55; i<59; i++)
  1244.     {
  1245.     for (j=i+1; j<60; j++)
  1246.         {
  1247.         if ( kortit[j] < kortit[i] )
  1248.             {
  1249.             apusuora1 = kortit[j];
  1250.             kortit[j] = kortit[i];
  1251.             kortit[i] = apusuora1;
  1252.             }
  1253.         }
  1254.     }
  1255.  
  1256. DeKoodaa();
  1257.  
  1258. /* LAJITELLAAN TAULUKON kortit[64-69] ALKIOT, PIENIN ENSIN */
  1259.  
  1260. for (i=65; i<69; i++)
  1261.     {
  1262.     for (j=i+1; j<70; j++)
  1263.         {
  1264.         if ( kortit[j] < kortit[i] )
  1265.             {
  1266.             apusuora1 = kortit[j];
  1267.             kortit[j] = kortit[i];
  1268.             kortit[i] = apusuora1;
  1269.             }
  1270.         }
  1271.     }
  1272.  
  1273. apusuora1=0;
  1274.  
  1275.     
  1276. /******************************* S U O R A *************************/   
  1277.  
  1278. if ( (kortit[69]-kortit[65]) ==4)
  1279.     apusuora1=1;
  1280. if ( ( (kortit[68]-kortit[65]) ==3) && (kortit[69]==15) )
  1281.     apusuora2=1;
  1282. if ( ( (kortit[68]-kortit[65]) ==4) && (kortit[69]==15) )
  1283.     apusuora3=1;
  1284. if ( (kortit[65]==1) && (kortit[66]==10) && (kortit[67]==11) && (kortit[68]==12) && (kortit[69]==13) )
  1285.     {
  1286.     voittonumero=5;
  1287.     suora=1;
  1288.     }
  1289. if ( (kortit[65]==1) && (kortit[66]==10) && (kortit[67]==11) && (kortit[68]==12) && (kortit[69]==15) )
  1290.     {
  1291.     voittonumero=5;
  1292.     suora=1;
  1293.     }
  1294. if ( (kortit[65]==1) && (kortit[66]==10) && (kortit[67]==12) && (kortit[68]==13) && (kortit[69]==15) )
  1295.     {
  1296.     voittonumero=5;
  1297.     suora=1;
  1298.     }
  1299. if ( (kortit[65]==1) && (kortit[66]==10) && (kortit[67]==11) && (kortit[68]==13) && (kortit[69]==15) )
  1300.     {
  1301.     voittonumero=5;
  1302.     suora=1;
  1303.     }
  1304. if ( (kortit[65]==1) && (kortit[66]==11) && (kortit[67]==12) && (kortit[68]==13) && (kortit[69]==15) )
  1305.     {
  1306.     voittonumero=5;
  1307.     suora=1;
  1308.     }
  1309. if ( kortit[69]==15 ) jokeri=1;             /* JOKERI MUKANA */
  1310.  
  1311.  
  1312. /******************************* P A R I T *************************/   
  1313.  
  1314. for (i=65; i<69; i++)
  1315.     if (kortit[i]==kortit[i+1]) pari++;
  1316.  
  1317.  
  1318. /**************************** K O L M O S E T **********************/   
  1319.  
  1320. for (i=65; i<68; i++)
  1321.     if ( (kortit[i]==kortit[i+1]) && (kortit[i+1]==kortit[i+2]) ) kolmoset++;
  1322.  
  1323.  
  1324. /*******************************************************************/   
  1325.  
  1326. if ( (kortit[60]==kortit[61]) && (kortit[61]==kortit[62]) && (kortit[62]==kortit[63]) )   apuvari=1;
  1327.  
  1328.  
  1329. /******************************* S U O R A *************************/   
  1330.  
  1331. if ( (pari==0) && (apusuora1 || apusuora2 || apusuora3) )
  1332.     {
  1333.     voittonumero=5;
  1334.     suora=1;
  1335.     }
  1336.  
  1337.  
  1338. /******************************** V Ä R I **************************/   
  1339.  
  1340. if ( apuvari && ( (kortit[64]==kortit[63]) || jokeri ) ) 
  1341.     {
  1342.     voittonumero=4;
  1343.     vari=1;
  1344.     }   
  1345.  
  1346.  
  1347. /******************************* R E E T I *************************/   
  1348.  
  1349. if ( vari && suora ) 
  1350.     voittonumero=1;
  1351.  
  1352.  
  1353. /************************* K A K S I  P A R I A ********************/   
  1354.  
  1355. if ( pari==2 && kolmoset==0)
  1356.     voittonumero=7;
  1357.  
  1358.  
  1359. /*************************** K O L M I L U K U *********************/   
  1360.  
  1361. if ( kolmoset==1 || ( (pari==1) && jokeri ) )
  1362.     voittonumero=6;
  1363.  
  1364.  
  1365. /**************************** T Ä Y S K Ä S I **********************/   
  1366.  
  1367. if ( ( (pari==2) && jokeri && kolmoset==0 ) || ( (pari==3) && (kolmoset==1) ) )
  1368.     voittonumero=3;
  1369.  
  1370.  
  1371. /**************************** N E L I L U K U **********************/   
  1372.  
  1373. if ( (kolmoset==2) || ( kolmoset==1 && jokeri ) )
  1374.     voittonumero=2;
  1375.  
  1376.  
  1377. /**************************** V I I T O S E T **********************/   
  1378.  
  1379. if ( (kolmoset==2) && jokeri )
  1380.     voittonumero=0;
  1381.  
  1382. return (voittonumero); 
  1383. }
  1384.  
  1385.  
  1386.  
  1387.  
  1388. /****** TÄMÄ FUNKTIO VÄHENTÄÄ PANOKSEN VERRAN PELISTÄ/VOITOISTA *******/
  1389.  
  1390. VOID VahennaRahaa()
  1391. {
  1392. pelit -= panokset[nytpanos];        /* PÄIVITETÄÄN HINNAT    */
  1393. if (pelit<0)                        /* PELIRAHA EI RIITTÄNYT */
  1394.     {
  1395.     voitot += pelit;                /* -> OTETAAN VOITOISTA  */
  1396.     pelit = 0;
  1397.     }
  1398. PrinttaaPelitVoitot();
  1399. }
  1400.  
  1401.  
  1402.  
  1403.  
  1404. /********  TÄMÄ FUNKTIO PRINTTAA PELIT JA VOITOT KONDIKSEEN **********/
  1405.  
  1406. VOID PrinttaaPelitVoitot()
  1407. {
  1408.  
  1409. sprintf(stringi, "%5ld", voitot);
  1410. TextText(RP, 260, 19, 4, stringi );
  1411.  
  1412. sprintf(stringi, "%2ld", pelit);
  1413. TextText(RP, 88, 19, 4, stringi );
  1414. }
  1415.  
  1416.  
  1417.  
  1418.  
  1419. /******** TÄMÄ FUNKTIO TARKISTAA RAHATILANTEEN, VÄHENTÄÄ YMS. *********/
  1420.  
  1421. VOID KatsoRahaTilanne()
  1422. {
  1423. SHORT panos=nytpanos;
  1424.  
  1425. if( (pelit+voitot) <= 0)
  1426.     {
  1427.     nytpanos = 0;
  1428.     PrinttaaPanos();
  1429.     GameOver();
  1430.     }
  1431. else
  1432.     {
  1433.     while( (pelit+voitot) < panokset[nytpanos] )
  1434.         nytpanos--;
  1435.  
  1436.     if ( nytpanos<2 )
  1437.         OtaPoisJokeri();
  1438.  
  1439.     if (panos!=nytpanos)
  1440.         PrinttaaPanos();
  1441.     }
  1442. }
  1443.  
  1444.  
  1445.  
  1446.  
  1447. /****************** TÄMÄ FUNKTIO VÄLÄYTTÄÄ PUNAISTA ******************/
  1448.  
  1449. VOID Valauta()
  1450. {
  1451. if ( voitot >= 50 )
  1452.     {
  1453.     VaritRuutuun(32);       /* PUNASÄVYINEN PALETTI */
  1454.     Delay(17);
  1455.     VaritRuutuun(0);        /* VÄRIT NORMAALIKSI */
  1456.     }
  1457. }
  1458.  
  1459.  
  1460.  
  1461.  
  1462. /********* TÄMÄ FUNKTIO PÄIVITTÄÄ GADGETIT ja nyt MYÖS VÄRIT *********/
  1463.  
  1464. VOID GadgetitKondixeen()
  1465. {
  1466. USHORT i;
  1467.     
  1468. RemoveGList(window, &Painike[5], -1);
  1469. AddGadget(window, &Eexit, -1);
  1470.  
  1471. if (pelitilanne == 1)                               /* PERUSTILANNE */
  1472.     {
  1473.     AddGadget(window, &Panos, -1);
  1474.     AddGadget(window, &Painike[3], -1);                 /* PANOS */
  1475.     SetRGB4(&screen->ViewPort, 20,  4, 12, 15);
  1476.         varitila[20]=1;
  1477.     SetRGB4(&screen->ViewPort, 21,  0, 10, 15);
  1478.         varitila[21]=1;
  1479.     SetRGB4(&screen->ViewPort, 22,  0,  7, 14);
  1480.         varitila[22]=1;
  1481.     AddGadget(window, &Painike[5], -1);                 /* JAKO  */
  1482.     SetRGB4(&screen->ViewPort, 26,  8, 15,  8);
  1483.         varitila[26]=1;
  1484.     SetRGB4(&screen->ViewPort, 27,  0, 14,  0);
  1485.         varitila[27]=1;
  1486.     SetRGB4(&screen->ViewPort, 28,  0, 11,  0);
  1487.         varitila[28]=1;
  1488.     AddGadget(window, &Voitot, -1);                 /* VOITOT YLHÄÄLLÄ */
  1489.     if (voitot>0)                                   /* VOITONMAKSU */
  1490.         {
  1491.         AddGadget(window, &Painike[4], -1);             /* VOITONM */
  1492.         SetRGB4(&screen->ViewPort, 23, 15, 15, 13);     
  1493.             varitila[23]=1;
  1494.         SetRGB4(&screen->ViewPort, 24, 15, 15,  5);     
  1495.             varitila[24]=1;
  1496.         SetRGB4(&screen->ViewPort, 25, 12, 12,  0);     
  1497.             varitila[25]=1;
  1498.         }
  1499.     }
  1500. if (pelitilanne == 2)                               /* EI 'VALITTU'JA */
  1501.     {
  1502.     AddGadget(window, &KorttiPohja[0], -1);         /* KORTIT */
  1503.     AddGadget(window, &KorttiPohja[1], -1);
  1504.     AddGadget(window, &KorttiPohja[2], -1);
  1505.     AddGadget(window, &KorttiPohja[3], -1);
  1506.     AddGadget(window, &KorttiPohja[4], -1);
  1507.     }
  1508. if (pelitilanne == 3)                               /* ON 'VALITTU'JA */
  1509.     {
  1510.     AddGadget(window, &KorttiPohja[0], -1);         /* KORTIT */
  1511.     AddGadget(window, &KorttiPohja[1], -1);
  1512.     AddGadget(window, &KorttiPohja[2], -1);
  1513.     AddGadget(window, &KorttiPohja[3], -1);
  1514.     AddGadget(window, &KorttiPohja[4], -1);
  1515.     AddGadget(window, &Painike[5], -1);             /* JAKO  */
  1516.     SetRGB4(&screen->ViewPort, 26,  8, 15,  8);
  1517.         varitila[26]=1;
  1518.     SetRGB4(&screen->ViewPort, 27,  0, 14,  0);
  1519.         varitila[27]=1;
  1520.     SetRGB4(&screen->ViewPort, 28,  0, 11,  0);
  1521.         varitila[28]=1;
  1522.     }
  1523. if (pelitilanne == 4)                               /* GADGETIT POIS */
  1524.     {
  1525.     AddGadget(window, &Pelit, -1);
  1526.     }
  1527. if (pelitilanne == 5)                       /* TUPLAUS / VOITONMAKSU */
  1528.     {
  1529.     AddGadget(window, &Voitot, -1);                 /* VOITOT YLHÄÄLLÄ */
  1530.     AddGadget(window, &Painike[0], -1);             /* TUPLAUS */
  1531.     SetRGB4(&screen->ViewPort, 11, 15, 11,  5);
  1532.         varitila[11]=1;
  1533.     SetRGB4(&screen->ViewPort, 12, 15,  9,  0);
  1534.         varitila[12]=1;
  1535.     SetRGB4(&screen->ViewPort, 13, 13,  6,  3);
  1536.         varitila[13]=1;
  1537.     AddGadget(window, &Painike[4], -1);             /* VOITONMAKSU */
  1538.     SetRGB4(&screen->ViewPort, 23, 15, 15, 13);     
  1539.         varitila[23]=1;
  1540.     SetRGB4(&screen->ViewPort, 24, 15, 15,  5);     
  1541.         varitila[24]=1;
  1542.     SetRGB4(&screen->ViewPort, 25, 12, 12,  0);     
  1543.         varitila[25]=1;
  1544.     }
  1545. if (pelitilanne == 6)                               /* PIENI / SUURI */
  1546.     {
  1547.     AddGadget(window, &Painike[1], -1);             /* PIENI */
  1548.     SetRGB4(&screen->ViewPort, 14, 15, 11,  5);
  1549.         varitila[14]=1;
  1550.     SetRGB4(&screen->ViewPort, 15, 15,  9,  0);
  1551.         varitila[15]=1;
  1552.     SetRGB4(&screen->ViewPort, 16, 13,  6,  3);
  1553.         varitila[16]=1;
  1554.     AddGadget(window, &Painike[2], -1);             /* SUURI */
  1555.     SetRGB4(&screen->ViewPort, 29, 15, 11,  5);
  1556.         varitila[29]=1;
  1557.     SetRGB4(&screen->ViewPort, 30, 15,  9,  0);
  1558.         varitila[30]=1;
  1559.     SetRGB4(&screen->ViewPort, 31, 13,  6,  3);
  1560.         varitila[31]=1;
  1561.     }
  1562. if (pelitilanne == 7)                               /* LISTALLA */
  1563.     {
  1564.     AddGadget(window, &Jono, -1);                   /* PIENI */
  1565.     }
  1566. if (pelitilanne == 11)                              /* GAME OVER */
  1567.     {
  1568.     AddGadget(window, &Pelit, -1);                  /* PELIT */
  1569.     }
  1570.  
  1571. for (i=11; i<32; i++)
  1572.     {
  1573.     if (varitila[i]==0)
  1574.         SetRGB4(&screen->ViewPort, i, varit[i*3], varit[i*3+1], varit[i*3+2]);
  1575.     varitila[i]=0;
  1576.     }
  1577.  
  1578. RefreshGList(&Painike[5], window, NULL, -1);    /* GADGETIT KEHIIN */
  1579. }
  1580.  
  1581.  
  1582.  
  1583.  
  1584. /**************************** PIIRTÄÄ PAKAN ****************************/
  1585.  
  1586. VOID PiirraPakka()
  1587. {
  1588. /*
  1589. SHORT i=3;
  1590.  
  1591. while(i--)
  1592.     {
  1593.     BltBitMapRastPort(&bitMap, 263, 161, RP, KORTTIX+i*2-4, 33+i*2, 51, 79, 0xC0);
  1594.     SetAPen(RP, 0);
  1595.     Move(RP, KORTTIX+i*2-3+KORTTIL, 33+i*2);
  1596.     Draw(RP, KORTTIX+i*2-3+KORTTIL, 33+i*2+KORTTIK+1);
  1597.     Draw(RP, KORTTIX+i*2-3, 33+i*2+KORTTIK+1);
  1598.     }
  1599. */
  1600. SetAPen(RP, 0);
  1601. RectFill(RP, 10, 32, 70, 115); 
  1602. BltBitMapRastPort(&bitMap, 263, 161, RP, KORTTIX-1, 35, 51, 79, 0xC0);
  1603. }
  1604.  
  1605.  
  1606.  
  1607.  
  1608. /******* TÄMÄ FUNKTIO OTTAA PAKASTA VIISI ENSIMMÄISTÄ KORTTIA ********/
  1609.  
  1610. VOID JaaAlkuKortit()
  1611. {
  1612. SHORT i=5;
  1613. SHORT ko;
  1614.  
  1615. while(i--)
  1616.     {
  1617.     ko= Satunnaisluku((SHORT)(4-i), (SHORT)(51+jokerimukana) ); 
  1618.     kortit[55+i] = kortit[ko];
  1619.     kortit[ko]   = kortit[4-i]; 
  1620.     kortit[4-i]  = kortit[55+i];
  1621.     }
  1622. }
  1623.  
  1624.  
  1625.  
  1626.  
  1627. /******************* TÄMÄ FUNKTIO OTTAA LOPUT KORTIT ******************/
  1628.  
  1629. VOID JaaLoputKortit()
  1630. {
  1631. SHORT x=0, i=5;
  1632. SHORT ko;
  1633.  
  1634. while(i--)
  1635.     {
  1636.     if(valittu[i]==0)
  1637.         {
  1638.         ko= Satunnaisluku( (SHORT)(5+x), (SHORT)(51+jokerimukana) ); 
  1639.         x++;
  1640.         kortit[55+i] = kortit[ko];
  1641.         kortit[ko]   = kortit[4+x]; 
  1642.         kortit[4+x]  = kortit[55+i];
  1643.         }
  1644.     }
  1645. }
  1646.  
  1647.  
  1648.  
  1649.  
  1650. /********** TÄMÄ FUNKTIO ANTAA SATUUNAISLUVUN VÄLILTÄ [A,B] **********/
  1651. /*   a = alin kokonaisluku, joka saa tulla arvonnassa
  1652.      b = ylin kokonaisluku, joka saa tulla arvonnassa */
  1653.  
  1654. SHORT Satunnaisluku(a, b)
  1655. SHORT a, b;
  1656. {
  1657. FLOAT satu;
  1658. USHORT luku;
  1659.     
  1660. luku = rand() ;
  1661. satu = luku / 1.0;
  1662. satu *= 1.52588693065;
  1663. satu /= 100000;
  1664.     
  1665. return ((SHORT)(satu*(b-a+1)+a));
  1666.  
  1667. }
  1668.  
  1669.  
  1670.  
  1671.  
  1672. /***************** DEKOODAA KORTIN MAAN JA NUMERON ******************/
  1673.  
  1674. VOID DeKoodaa()
  1675. {
  1676. SHORT i=5;
  1677.  
  1678. while(i--)
  1679.     {
  1680.     kortit[60+i] = kortit[55+i]&'\xf0' ;            /* MAA    */
  1681.     kortit[65+i] = kortit[55+i]&'\x0f' ;            /* NUMERO */
  1682.     }
  1683. }
  1684.  
  1685.  
  1686.  
  1687.  
  1688. /******************* RAHAT LOPPU ---->>  GAMEOVER ********************/
  1689.  
  1690. VOID GameOver()
  1691. {
  1692. PuhdistaAlapalkki();
  1693. pelitilanne = 11;
  1694. GadgetitKondixeen();
  1695. VaritRuutuun(64);               /* VÄRIT VIHREÄNSÄVYISIKSI */
  1696. Sound(8, 100, 3);
  1697. }
  1698.  
  1699.  
  1700.  
  1701.  
  1702. /************** TÄMÄ FUNKTIO OTTAA JOKERIN POIS PAKASTA **************/
  1703.  
  1704. VOID OtaPoisJokeri()
  1705. {
  1706. SHORT i=0;
  1707.  
  1708. while(kortit[i++] != 0xFF)
  1709.     {
  1710.         ;
  1711.     }
  1712.     kortit[i-1] = kortit[52];
  1713.     kortit[52] = 0xFF;
  1714.     jokerimukana = 0;
  1715. }
  1716.  
  1717.  
  1718.  
  1719.  
  1720. /****************** KILISTETÄÄN RAHAA ALHAALTA YLÖS ********************/
  1721.  
  1722. VOID KilistysAAYY()
  1723. {
  1724. SHORT i;
  1725.  
  1726. for(i=panokset[nytpanos]; i<(tuplavoitto+1); i+=panokset[nytpanos])
  1727.     {
  1728.     sprintf(stringi, "%5ld", i+voitot);
  1729.     TextText(RP, 260, 19, 4, stringi); 
  1730.     sprintf(stringi, "%3ld", tuplavoitto-i);
  1731.     TextText(RP, 77, 215, 4, stringi); 
  1732.     Sound(3, 100, 0);
  1733.     Delay( (LONG)((TICKS_PER_SECOND*panokset[nytpanos]) / tuplavoitto) );
  1734.     }
  1735. voitot += tuplavoitto;
  1736. Valauta();
  1737. }
  1738.  
  1739.  
  1740.  
  1741.  
  1742. /***************** KILISTETÄÄN RAHAA ALHAALLA YLÖSPÄIN ******************/
  1743.  
  1744. VOID KilistysAY()
  1745. {
  1746. SHORT i;
  1747.  
  1748. for(i=(tuplavoitto==voittosumma)?panokset[nytpanos]:
  1749.             tuplavoitto/2+panokset[nytpanos];
  1750.             i<(tuplavoitto+1); i+=panokset[nytpanos])
  1751.     {
  1752.     sprintf(stringi, "%3ld", i);
  1753.     TextText(RP, 77, 215, 4, stringi); 
  1754.     Sound(3, 100, 1);
  1755.     Delay( (LONG)((TICKS_PER_SECOND*panokset[nytpanos]) / tuplavoitto) );
  1756.     }
  1757. }
  1758.  
  1759.  
  1760.  
  1761.  
  1762. /***************** KILISTETÄÄN RAHAA YLHÄÄLLÄ YLÖSPÄIN ******************/
  1763.  
  1764. VOID KilistysYY()
  1765. {
  1766. SHORT i;
  1767.  
  1768. for(i=voitot+panokset[nytpanos]; i<(voitot+tuplavoitto+1);
  1769.             i+=panokset[nytpanos])
  1770.     {
  1771.     sprintf(stringi, "%5ld", i);
  1772.     TextText(RP, 260, 19, 4, stringi); 
  1773.     Sound(3, 100, 2);
  1774.     Delay( (LONG)((TICKS_PER_SECOND*panokset[nytpanos]) / tuplavoitto) );
  1775.     }
  1776. voitot += tuplavoitto;
  1777. Valauta();
  1778. }
  1779.  
  1780.  
  1781.  
  1782.  
  1783. /********* TULOSTETAAN RUUDUN VÄRIT TAULUKOSTA KOHDASTA taulu ***********/
  1784.  
  1785. VOID VaritRuutuun(taulu)        /* taulu VOI SAADA ARVOJA 0, 32, 64, 96 */
  1786. SHORT taulu;
  1787. {
  1788. USHORT i;
  1789.  
  1790. for (i=0; i<11; i++)
  1791.     {
  1792.     SetRGB4(&screen->ViewPort, i, varit[(i+taulu)*3], varit[(i+taulu)*3+1], varit[(i+taulu)*3+2]);
  1793.     }
  1794. SetRGB4(&screen->ViewPort, 18, varit[(18+taulu)*3], varit[(18+taulu)*3+1], varit[(18+taulu)*3+2]);
  1795. SetRGB4(&screen->ViewPort, 19, varit[(19+taulu)*3], varit[(19+taulu)*3+1], varit[(19+taulu)*3+2]);
  1796.  
  1797. }
  1798.  
  1799.  
  1800.  
  1801.  
  1802. /*********************** JAKO-NAPPULA NOSTETTU ***************************/
  1803.  
  1804. VOID Jako()
  1805. {
  1806. if(pelitilanne==1)          /* 1. JAKO */
  1807.     {
  1808.     if (ReadPixel(RP, 2, 202) == 3L)        /* ALAPALKKI ON PUNAINEN */
  1809.         PuhdistaAlapalkki();
  1810.     pelitilanne = 2;
  1811.     GadgetitKondixeen();
  1812.     VahennaRahaa();
  1813.     JaaAlkuKortit();
  1814.     if (tyhjennys==1)       /* PELIKENTTÄ ON TYHJÄ */
  1815.         {
  1816.         TulostaKortit();
  1817.         }
  1818.     else if (tyhjennys==2)  /* VIISI KORTTIA */
  1819.         {
  1820.         KortitKasaan();
  1821.         Delay(VIIVE);
  1822.         TulostaKortit();
  1823.         }
  1824.     else if (tyhjennys==3)  /* YKSI KORTTI KESKELLÄ */
  1825.         {
  1826.         KortitPakkaan();
  1827.         Delay(VIIVE);
  1828.         TulostaKortit();
  1829.         }
  1830.     else                    /* LISTA NÄKYVISSÄ */
  1831.         {
  1832.         SetAPen(RP, 0);
  1833.         RectFill(RP, 5, 32, 319, 197);      /* RUUTU TYHJÄKSI */
  1834.         tyhjennys=2;
  1835.         TulostaKortit();
  1836.         }
  1837.     tyhjennys = 2;          /* NYT PÖYDÄLLÄ VIISI KORTTIA */
  1838.     }
  1839. if(pelitilanne==3)          /* 2. JAKO */
  1840.     {
  1841.     pelitilanne = 4;        /* GADGETIT POIS PÄÄLTÄ */
  1842.     GadgetitKondixeen();
  1843.     JaaLoputKortit();
  1844.     KortitPois();
  1845.     Delay(VIIVE);
  1846.     TulostaKortit2();
  1847.     nytvoitto = TarkistaVoitot();
  1848.     if (nytvoitto <8)       /* VOITTO TULI!! */
  1849.         {
  1850.         voittosumma = voittosummat[nytpanos][nytvoitto];
  1851.         tuplavoitto = voittosumma;
  1852.  
  1853.         /***** VOITTO TARPEEKSI SUURI -> YLÖS ******/
  1854.         if (voittosumma>100)
  1855.             {
  1856.             sprintf(stringi, "%s %4d MK", voittonimet[8*KIELI+nytvoitto], voittosumma);
  1857.             PlainText(RP, 147, (SHORT)(45+nytvoitto*9), 3, 0, stringi );
  1858.             KilistysYY();               
  1859.             PuhdistaAlapalkki();
  1860.             pelitilanne = 1;
  1861.             GadgetitKondixeen();
  1862.             tyhjennys=2;
  1863.             sprintf(stringi, "%s  %4d", voittonimet[8*KIELI+nytvoitto], voittosumma);
  1864.             PlainText(RP, 147, (SHORT)(45+nytvoitto*9), 7, 0, stringi );
  1865.             }
  1866.         else    /* VOITTO EI OLLUT LIIAN SUURI -> TUPLAUS */
  1867.             {
  1868.             PuhdistaAlapalkki();
  1869.             pelitilanne = 5;        /* TUPLAUS / VOITONMAKSU */
  1870.             GadgetitKondixeen();
  1871.             SetAPen(RP, 3);
  1872.             RectFill(RP, 0, 199, 319, 223); /* ALAPALKKI PUNAISEKSI */
  1873.             sprintf(stringi, "%s  %4d", voittonimet[8*KIELI+nytvoitto], voittosumma);
  1874.             PlainText(RP, 147, (SHORT)(45+nytvoitto*9), 3, 0, stringi );
  1875.  
  1876.             ColorSquare(RP, 70, 202, 36, 18, 8);        /* ALALOOTA */
  1877.  
  1878.             sprintf(stringi, SekaTextit[12+KIELI]);
  1879.             ShadowText(RP,  16, 215, 1, 4, stringi );
  1880.             KilistysAY();       /* RAHAA ALAPALKKIIN */
  1881.             }
  1882.         }
  1883.     else                        /* VOITTOA EI HERUNUT */
  1884.         {
  1885.         PuhdistaAlapalkki();
  1886.         pelitilanne = 1;
  1887.         GadgetitKondixeen();
  1888.         KatsoRahaTilanne();
  1889.         tyhjennys=2;
  1890.         }
  1891.     }       /* if (pelitilanne == 3) */
  1892. }           /* end of Jako()         */
  1893.  
  1894.  
  1895.  
  1896.  
  1897. /**************************** MUUTA KIELTÄ ******************************/
  1898.  
  1899. VOID MuutaKielta(kieli) /* kieli == 0 => SUOMI, 1 = ENGLANTI, 2 = RUOTSI */
  1900. UBYTE kieli;
  1901. {
  1902. SHORT i;
  1903.  
  1904. if (kieli == 0 && KIELI != 0)   /* SUOMEKSI */
  1905.     {
  1906.     for (i=0; i<6; i++)
  1907.         {
  1908.         Painike[5-i].GadgetRender = (APTR)&PainikeImage[i*2];
  1909.         Painike[5-i].SelectRender = (APTR)&PainikeImage[i*2+1];
  1910.         }
  1911.     KIELI = 0;
  1912.     TekstiPelitVoitot(KIELI);
  1913.     }
  1914.  
  1915. if (kieli == 1 && KIELI != 1)   /* ENGLANNIKSI */
  1916.     {
  1917.     for (i=0; i<6; i++)
  1918.         {
  1919.         Painike[5-i].GadgetRender = (APTR)&PainikeImage[12+i*2];
  1920.         Painike[5-i].SelectRender = (APTR)&PainikeImage[13+i*2];
  1921.         }
  1922.     KIELI = 1;
  1923.     TekstiPelitVoitot(KIELI);
  1924.     }
  1925.  
  1926. if (kieli == 2 && KIELI != 2)   /* RUOTSIKSI */
  1927.     {
  1928. /*  KIELI = 2; */
  1929.     }
  1930.  
  1931. RemoveGList(window, &Painike[5], -1);
  1932. AddGadget(window, &Painike[5], -1);
  1933. RefreshGadgets(&Painike[5], window, NULL);
  1934. AddGadget(window, &Painike[4], -1);
  1935. RefreshGadgets(&Painike[4], window, NULL);
  1936. AddGadget(window, &Painike[3], -1);
  1937. RefreshGadgets(&Painike[3], window, NULL);
  1938. AddGadget(window, &Painike[2], -1);
  1939. RefreshGadgets(&Painike[2], window, NULL);
  1940. AddGadget(window, &Painike[1], -1);
  1941. RefreshGadgets(&Painike[1], window, NULL);
  1942. AddGadget(window, &Painike[0], -1);
  1943. RefreshGadgets(&Painike[0], window, NULL);
  1944. GadgetitKondixeen();
  1945. TulostaVoittoluokat();
  1946. }
  1947.  
  1948.  
  1949.  
  1950.  
  1951. /******************************** ABOUT *********************************/
  1952.  
  1953. #if defined FEA_NOT_ENGLISH_GIFTWARE
  1954. VOID Aboutti()
  1955. {
  1956. struct Window *aboutwindow;
  1957. struct IntuiMessage *mssg = NULL;   /* VIESTIPOINTTERI              */
  1958. SHORT  lippu;                       /* FALSE, KUN ABOUTTI LOPPUU    */
  1959. ULONG  luokka;                      /* INTUITIONVIESTIN LUOKITUS    */
  1960. SHORT  i;
  1961.  
  1962. aboutWindow.Screen = screen;
  1963.  
  1964. if ( aboutwindow = (struct Window *)OpenWindow(&aboutWindow) )
  1965.     {
  1966.     SetPointer(aboutwindow, XPointer, 15, 16, -8, -9);  /* OMA POINTTERI */
  1967.  
  1968.     RemoveGList(window, &Painike[5], -1);
  1969.     AddGList(aboutwindow, &About, 0, -1, NULL);
  1970.     RefreshGList(&About, aboutwindow, NULL, -1);
  1971.  
  1972.     ColorSquare(aboutwindow->RPort,   0,   0, 259, 213, 26);
  1973.     ColorSquare(aboutwindow->RPort, 201, 184,  48,  18, 20);
  1974.  
  1975.     PlainText(aboutwindow->RPort,  216, 197, 4, 21, "OK!" );
  1976.  
  1977.     for (i=0; i<17; i++)
  1978.         {
  1979.         PlainText(aboutwindow->RPort, 131-TextLength(aboutwindow->RPort,
  1980.         abouttext[i], strlen(abouttext[i]))/2, i*10+20, 22, 27, abouttext[i] );
  1981.         }
  1982.  
  1983.     lippu=TRUE;
  1984.     while(lippu)                    /* KUNNES lippu == FALSE (LOPPUU) */
  1985.         {
  1986.         Wait ( 1L << aboutwindow->UserPort->mp_SigBit);
  1987.         while (mssg=(struct IntuiMessage *)GetMsg(aboutwindow->UserPort))
  1988.             {
  1989.             luokka=mssg->Class;         /* VIESTILUOKKA */
  1990.             switch(luokka)
  1991.                 {
  1992.                 case RAWKEY:
  1993.                     if ( mssg->Code == 95 )     /* HELP = TAKAISIN */
  1994.                         {
  1995.                         lippu = FALSE;
  1996.                         }
  1997.                     break;
  1998.                 case GADGETUP:          /* KÄSITELLÄÄN GADGET-YLÖS */
  1999.                     lippu = FALSE;
  2000.                     break;
  2001.                 default:
  2002.                     break;
  2003.                 }
  2004.             ReplyMsg((struct Message *)mssg);   /* VASTATAAN VIESTEIHIN */
  2005.             }
  2006.         }
  2007.  
  2008.     RemoveGList(aboutwindow, &About, -1);
  2009.     AddGList(window, &Painike[5], 0, -1, NULL);
  2010.     RefreshGList(&Painike[5], window, NULL, -1);
  2011.     CloseWindow(aboutwindow);
  2012.     PrinttaaPanos();                    /* PÄIVITÄ PELIMARKKA */
  2013.     }
  2014. }
  2015. #endif
  2016.  
  2017.  
  2018.  
  2019. /********** FUNKTIO ALUSTAA GRAFIIKAT, GADGETIT JA TEKSTIT ***********/
  2020.  
  2021. VOID Initialize(VOID)
  2022. {
  2023. SHORT i;
  2024. SHORT depth;
  2025. ULONG sekunnit, mikrot;
  2026.  
  2027. oldTextFont = RP->Font;
  2028. textAttr.ta_Name  = "Topaz.font";
  2029. textAttr.ta_YSize = 11;
  2030. textAttr.ta_Style = FS_NORMAL;
  2031. textAttr.ta_Flags = FPF_DESIGNED | FPF_DISKFONT;
  2032.  
  2033. if (!(textFont = (struct TextFont *)OpenDiskFont(&textAttr)))
  2034.     {
  2035.     cleanExit(10);
  2036.     }
  2037.  
  2038. VaritRuutuun(0);                    /* NORMAALIVÄRIT */
  2039.  
  2040. /* OTETAAN BITTIKARTTA KÄYTTÖÖN (SUURI GRAFIIKKARUUTU) */
  2041.  
  2042. InitBitMap(&bitMap, 5, 320, 256);
  2043.  
  2044. for(depth=0; depth<5; depth++)
  2045.     {
  2046.     bitMap.Planes[depth] = (UBYTE *)(muistinalku+depth*10240);
  2047.     }
  2048.  
  2049. /* BITTIKARTTA OSOITTAA NYT muistinalku:un JA VOIDAAN KÄYTTÄÄ 
  2050.         MUUTTUJAA &bitMap VIITTAAMAAN TÄHÄN KARTTAAN            */
  2051.  
  2052. /* OTETAAN BITTIKARTTA KÄYTTÖÖN (TILA YHDELLE KORTILLE) */
  2053.  
  2054. InitBitMap(&cardbitMap, 5, 56, 88);     /* KORTIN KOKO */
  2055.  
  2056. for(depth=0; depth<5; depth++)
  2057.     {
  2058.     cardbitMap.Planes[depth] = NULL;
  2059.     }
  2060.  
  2061. for(depth=0; depth<5; depth++)
  2062.     {
  2063.     cardbitMap.Planes[depth] = (PLANEPTR)AllocRaster(56, 88);
  2064.     if (cardbitMap.Planes[depth] == NULL)
  2065.         {
  2066.         cleanExit(2);
  2067.         }
  2068.     }
  2069.  
  2070. /* MUUTTUJAA &cardbitMap VOIDAAN KÄYTTÄÄ VIITTAAMAAN TÄHÄN
  2071.    KARTTAAN, JOHON VOIDAAN PIIRTÄÄ YKSI KORTTI */
  2072.  
  2073. InitRastPort(&cardRP);              /* LINKATAAN KORTIN BITTIKARTTA */
  2074. cardRP.BitMap = &cardbitMap;        /* RASTPORTTIIN, JOTTA VOIDAAN  */
  2075.                                         /* KÄYTTÄÄ PIIRTORUTIINEJA YMS. */
  2076.  
  2077. SetAPen(&cardRP, 0);
  2078. RectFill(&cardRP, 0, 0, 56, 84 );
  2079.  
  2080. SetDrMd (RP, JAM1);                     /* ASETTAA PIIRTOMOODIN */
  2081.  
  2082. SetAPen(RP, 1);
  2083. RectFill( RP, 0, 0, 319, 30 );      /* YLÄPALKKI */
  2084.  
  2085. AddGList(window, &Painike[5], 0, -1, NULL);
  2086. RefreshGList(&Painike[5], window, NULL, -1);
  2087.  
  2088. GadgetitKondixeen();
  2089.  
  2090. RectFill( RP, 0, 199, 319, 223 );       /* ALAPALKKI */
  2091.  
  2092. ColorSquare(RP, 14, 6, 95, 18, 8);          /* PELIT-boxi */
  2093. ColorSquare(RP, 193, 6, 112, 18, 8);        /* VOITOT-boxi */
  2094. PrinttaaPelitVoitot();
  2095.  
  2096. TekstiPelitVoitot(KIELI);
  2097.     
  2098. if (nytpanos>1)
  2099.     {
  2100.     sprintf(stringi, "%s  %4d", voittonimet[8*KIELI], voittosummat[nytpanos][0]);
  2101.     PlainText(RP, 147, 45, 7, 0, stringi );
  2102.     }
  2103.  
  2104. for (i=1; i<8; i++)
  2105.     {
  2106.     sprintf(stringi, "%s  %4d", voittonimet[8*KIELI+i], voittosummat[nytpanos][i]);
  2107.     PlainText(RP, 147, (SHORT)(45+i*9), 7, 0, stringi );
  2108.     }
  2109.  
  2110. PiirraPakka();      /* PAKAN PIIRTO */
  2111.  
  2112. SetPointer(window, XPointer, 15, 16, -8, -9);   /* OMA POINTTERI */
  2113.         
  2114. /* PANOKSEN PRINTTAUS */
  2115.  
  2116. sprintf(stringi, "%d", panokset[nytpanos]);
  2117. ShadowText(RP, (SHORT)((strlen(stringi)==2)?140:144), 18, 18, 19, stringi);
  2118.  
  2119. MuutaKielta(ALOITUSKIELI);
  2120.  
  2121. ScreenToFront(screen);              /* PELINÄYTTÖ ESIIN */
  2122.  
  2123. for (i=0; i<32; i++)
  2124.     {
  2125.     varitila[i]=0;                  /* NOLLATAAN MUUTETUT VÄRITILAT */
  2126.     }
  2127.  
  2128. CurrentTime(&sekunnit, &mikrot);
  2129. srand((USHORT)(mikrot/16)); 
  2130. }
  2131.  
  2132.  
  2133.  
  2134.  
  2135. /** FUNKTIO AVAA KAIKKI KIRJASTOT, NÄYTÖN, IKKUNAT, GRAFIIKAN JA FONTIN **/
  2136.  
  2137. VOID OpenAll(VOID)
  2138. {
  2139. LONG luettuja = 0;
  2140. SHORT i;
  2141.  
  2142. if (!(IntuitionBase = (struct IntuitionBase *)
  2143.     OpenLibrary( "intuition.library",33L)))
  2144.     {
  2145.     cleanExit(3);
  2146.     }
  2147. else if (!(DiskfontBase = OpenLibrary("diskfont.library", 33L)))
  2148.     {
  2149.     cleanExit(4);
  2150.     }
  2151. else if (!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",33L)))
  2152.     {
  2153.     cleanExit(5);
  2154.     }
  2155.  
  2156. if (GfxBase->DisplayFlags & PAL )
  2157.     {
  2158.     clock = 3546895L;
  2159.     }
  2160. else
  2161.     {
  2162.     clock = 3579545L;
  2163.     }
  2164.  
  2165. fullLORES.DefaultTitle = "VideoPokeri 1.02 © 1992-1994 JanTAki";
  2166.  
  2167. if (!(screen = (struct Screen *)OpenScreen(&fullLORES)))
  2168.     {
  2169.     cleanExit(6);
  2170.     }
  2171.  
  2172. graniteWindow.Screen = screen;
  2173.  
  2174. if (!(window = (struct Window *)OpenWindow(&graniteWindow)))
  2175.     {
  2176.     cleanExit(7);
  2177.     }
  2178.  
  2179. infile = (struct FileHandle *)Open("POKERI.RAW", MODE_OLDFILE);
  2180. if ( infile == 0)
  2181.     {
  2182.     cleanExit(8);
  2183.     }
  2184. else
  2185.     {
  2186.     mypointer = (APTR)AllocMem(51202, MEMF_CHIP);
  2187.     if (!mypointer)
  2188.         {
  2189.         Close((BPTR)infile);
  2190.         cleanExit(9);
  2191.         }
  2192.  
  2193.     luettuja = Read((BPTR)infile, mypointer, 51202);
  2194.     muistinalku = (UBYTE *)mypointer;
  2195.     Close((BPTR)infile);
  2196.     }
  2197.  
  2198. infile = (struct FileHandle *)Open("POKERI.HIGHSCORE", MODE_OLDFILE);
  2199. if ( infile == 0)
  2200.     {
  2201.     for(i=0; i<15; i++)
  2202.         {
  2203.         sprintf(lista[i],"Commodore 13.07.1994        %3d", 300-i*20);
  2204.         tulos[i] = 300-i*20;
  2205.         }
  2206.     }
  2207. else
  2208.     {
  2209.     for(i=0; i<15; i++)
  2210.         {
  2211.         luettuja=Read((BPTR)infile, lista[i], 30);
  2212.         lista[i][29]='\0';
  2213.         tulos[i]=atoi(&lista[i][25]);
  2214.         }
  2215.     Close((BPTR)infile);
  2216.     }
  2217. }
  2218.  
  2219.  
  2220.  
  2221.  
  2222.  
  2223. /******* FUNKTIO SULKEE KAIKKI AVATUT JUTUT JA POISTUU OHJELMASTA *******/
  2224.  
  2225. VOID cleanExit (returnValue)
  2226. SHORT returnValue;
  2227. {
  2228. SHORT i;
  2229.  
  2230. for(i=0; i<SOUND_MAX; i++)
  2231.     {
  2232.     if (sbase[i])
  2233.         {
  2234.         FreeMem(sbase[i], ssize[i]);
  2235.         }
  2236.     }
  2237. for(i=0; i<5; i++)
  2238.     {
  2239.     if (cardbitMap.Planes[i])
  2240.         {
  2241.         FreeRaster(cardbitMap.Planes[i], 56, 88);
  2242.         }
  2243.     }
  2244.  
  2245. if (device1  == 0)  CloseDevice( (struct IORequest *)AIOptr1);
  2246. if (device2  == 0)  CloseDevice( (struct IORequest *)AIOptr2);
  2247. if (port1)          DeletePort(port1);
  2248. if (port2)          DeletePort(port2);
  2249. if (AIOptr1)        FreeMem(AIOptr1, sizeof(struct IOAudio) );
  2250. if (AIOptr2)        FreeMem(AIOptr2, sizeof(struct IOAudio) );
  2251. if (mypointer)      FreeMem(mypointer, 51202);
  2252. if (textFont)       CloseFont(textFont);
  2253. if (window)         CloseWindow(window);
  2254. if (screen)         CloseScreen(screen);
  2255. if (DiskfontBase)   CloseLibrary( ( struct Library *) DiskfontBase);
  2256. if (IntuitionBase)  CloseLibrary( ( struct Library *) IntuitionBase);
  2257.  
  2258. if (returnValue!=0)
  2259.     {
  2260.     printf("\nVideoPokeri: %s\n%s!\n\n", SekaTextit[18+KIELI],
  2261.                            virhetekstit[KIELI+3*returnValue]);
  2262.     }
  2263. if ( FromWB == TRUE )
  2264.     {
  2265.     Delay(200);
  2266.     }
  2267. exit (returnValue>0?RETURN_ERROR:RETURN_OK);
  2268. }
  2269.  
  2270. /* END OF .C FILE */
  2271.